package com.mj.BinaryTreebak.BinarySearchTree;

import com.mj.printer.BinaryTreeInfo;

import java.util.Comparator;
import java.util.LinkedList;
import java.util.Queue;

/**
 * @Author: LDeng
 * @Date: 2021-02-26 9:06
 */
public class BinarySearchTree<E> implements BinaryTreeInfo {

    private int size;
    private Node<E> root;//根节点属性
    private Comparator<E> comparator;


    public BinarySearchTree() {//提供空构造 ， 让使用者可以不传比较器而使用默认的比较器
        this(null);
    }

    public BinarySearchTree(Comparator<E> comparator) {
        this.comparator = comparator;
    }

    public int size() {
        return size;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public void clear() {
           root=null;
           size=0;
    }

    public void add(E element) {
        elementNotNullCheck(element);
        if (root == null) {//添加第一个节点
            root = new Node<E>(element, null);
            size++;
            return;
        }
        //添加的不是第一个节点
        //找要插入元素的到父节点
        Node<E> parent = root;
        Node<E> node = root;
        int comp = 0;
        while (node != null) {
            comp = compare(element, node.element);
            parent = node;
            if (comp > 0) {//element>node.element 传进来的元素大于节点元素
                node = node.right;
            } else if (comp < 0) {//
                node = node.left;
            } else {//相等, 直接返回
                node.element = element;//使用传进来的元素覆盖原来的元素
                return;
            }
        }
        // 插入到父节点的左边还是右边
        Node<E> newNode = new Node<>(element, parent);
        if (comp > 0) {
            parent.right = newNode;
        } else {
            parent.left = newNode;
        }
        size++;
    }

    //对外提供删除元素的接口
    public void remove(E element) {
        Node<E> nodeByElement = getNodeByElement(element);
        remove(nodeByElement);
    }

    public void remove1(E element) {
        Node<E> nodeByElement = getNodeByElement(element);
        remove1(nodeByElement);
    }

    //对内使用删除节点的接口
    private void remove(Node<E> node) { //后继节点覆盖被删除节点
        if (node == null) return;
        size--;
        if (node.hasTwoChildren()) {//度为2, 使用被删除节点的前驱或者后继节点取代被删除的节点
            //找到后继节点
            Node<E> s = successor(node);
            //用后继节点的值覆盖node节点的值
            node.element = s.element;
            //删除后继节点
            node = s;//将node指向s节点， 为了下面统一删除度为1 和 0 的节点， 这里只做一个指向
        }
        //删除node节点（能执行到这里， node的度必然是1或者0）
        Node<E> replacement = node.left != null ? node.left : node.right;
        if (replacement != null) {//node 度为1的节点
            //更改node的parent
            replacement.parent = node.parent;
            //更改parent的left,right
            if (node.parent == null) {//node 度为1，并且是根节点
                root = replacement;
            } else if (node == node.parent.left) {
                node.parent.left = replacement;
            } else {//node == node.parent.right
                node.parent.right = replacement;
            }
        } else if (node == root) {//node度为0=>叶子节点,并且只有一个根节点
            root = null;
        } else {//node是叶子节点，但不是根节点
            if (node == node.parent.left) {//node在父节点的左边
                node.parent.left = null;
            } else {//node在父节点的右边
                node.parent.right = null;
            }
        }
    }

    private void remove1(Node<E> node){//前驱节点覆盖被删除节点
        if(node==null) return;//元素对应的节点不存在
        size--;
        if(node.hasTwoChildren()){
            Node<E> pre = predecessor(node);
            node.element=pre.element;   //值覆盖
            node=pre; //将node节点指向后继节点，并删除后继节点
                     // 与下面删除度为0或者1的节点逻辑统一处理
        }
        //删除node节点（此时node节点必然是度为0 或者度为 1）
        Node<E> replacement=node.left!=null?node.left:node.right;
        if(replacement!=null){//node是度为1的节点
            if(node.parent==null){//node是根节点
                root=replacement;
                replacement.parent=null;
            }else{//不是根节点
                if(node==node.parent.left){
                    replacement.parent=node.parent;
                    node.parent.left=replacement;
                }else{
                    replacement.parent=node.parent;
                    node.parent.right=replacement;
                }
            }
        }else { //node是度为0的节点（叶子节点）, 用replacement是否为空来判断是不是叶子节点
           if(node.parent==null){//叶子节点是根节点
               root=null;
           }else{
               if(node==node.parent.left){
                   node.parent.left=null;
               }else{
                   node.parent.right=null;
               }
           }
        }
    }

    //通过元素查找节点的方法
    private Node<E> getNodeByElement(E element) {
        Node<E> node = root;
        while (node != null) {
            int compar = compare(element, node.element);
            if (compar == 0) return node;
            if (compar > 0) {
                node = node.right;
            } else {
                node = node.left;
            }
        }
        return null;
    }

    public boolean contains(E element) {

        return getNodeByElement(element)!=null;
    }

    //前序遍历二叉树（根->左->右）
    public void preorderTraversal(Visitor<E> visitor) {
        if (visitor == null) return;
        preorderTraversal(root, visitor);
    }

    //前序遍历二叉树
    public void preorderTraversal(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor.stop) return;
        visitor.stop = visitor.visit(node.element);
        preorderTraversal(node.left, visitor);
        preorderTraversal(node.right, visitor);
    }

    //中序遍历(左->根->右)
    public void inorderTraversal(Visitor<E> visitor) {
        if (visitor == null) return;
        inorderTraversal(root, visitor);
    }

    public void inorderTraversal(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor.stop) return;
        inorderTraversal(node.left, visitor);
        if (visitor.stop) return;
        visitor.stop = visitor.visit(node.element);
        inorderTraversal(node.right, visitor);
    }

    //后序遍历(左->右->根)
    public void postorderTraversal(Visitor<E> visitor) {
        if (visitor == null) return;
        postorderTraversal(root, visitor);
    }

    public void postorderTraversal(Node<E> node, Visitor<E> visitor) {
        if (node == null || visitor.stop) return;//递归终止判断
        postorderTraversal(node.left, visitor);
        postorderTraversal(node.right, visitor);
        if (visitor.stop) return;
        visitor.stop = visitor.visit(node.element);

    }

    //层序遍历
    public void levelOrder(Visitor<E> visitor) {
        if (root == null || visitor == null) return;
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);//根节点入队
        while (!queue.isEmpty()) {
            Node<E> node = queue.poll();//头节点出队
            if (visitor.visit(node.element)) return;//将元素传出去， 并获取返回值（boolean）， true 就不在入队循环
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
        }
    }

    //前驱节点， 中序遍历时的前一个节点（左子树的最后一个节点）
    private Node<E> predecessor(Node<E> node) {
        if (node == null) return null;
        //1 ，左边不为空，前驱节点在左子树中(left.right.right.....)
        Node<E> p = node.left;
        if (p != null) {
            p = node.left;
            while (p.right != null) {
                p = p.right;
            }
            return p;
        }
        //从父节点，祖父节点。。。中寻找前驱节点,
        // 父节点不为空， 并且本节点在父节点的左子树中
        while (node.parent != null && node == node.parent.left) {
            node = node.parent;
        }

        //node.parent==null ==>返回空（node.parent）
        //node==node.parent.right ==> 本节点的parent节点就是前驱
        return node.parent;
    }

    //后续节点， 中序遍历时的前一个节点（左子树的最后一个节点）
    private Node<E> successor(Node<E> node) {
        if (node == null) return null;
        //1 ，右边不为空，前驱节点在右子树中(right.left.left.....)
        Node<E> p = node.right;
        if (p != null) {
            p = node.right;
            while (p.left != null) {
                p = p.left;
            }
            return p;
        }
        //从父节点，祖父节点。。。中寻找前驱节点,
        // 父节点不为空， 并且本节点在父节点的左子树中
        while (node.parent != null && node == node.parent.right) {
            node = node.parent;
        }

        //node.parent==null ==>返回空（node.parent）
        //node==node.parent.right ==> 本节点的parent节点就是前驱
        return node.parent;
    }


    public Node<E> getPrev(E element) {
        return null;
    }

    public static abstract class Visitor<E> {
        boolean stop;

        //如果返回true, 就停止遍历
        abstract boolean visit(E element);
    }

    // 返回值=0 e1,e2相等，
    // 返回值>0 e1>e2
    // 返回值<0 e1<e2
    private int compare(E e1, E e2) {//上面对泛型进行了约束， 传进来的对象必然是实现了Comparable接口的对象， 可比较
        if (comparator != null) {
            return comparator.compare(e1, e2);
        }
        return ((Comparable<E>) e1).compareTo(e2);
    }

    private void elementNotNullCheck(E element) {
        if (element == null) {
            throw new IllegalArgumentException("element must not be null");
        }
    }


    //节点类
    private static class Node<E> {
        E element;//节点存储的元素
        Node<E> left;
        Node<E> right;
        Node<E> parent;

        public Node(E element, Node<E> parent) {//构造
            this.element = element;
            this.parent = parent;
        }

        public boolean isLeaf() {
            return left == null && right == null;
        }

        public boolean hasTwoChildren() {
            return left != null && right != null;
        }
    }

    @Override
    public Object root() {
        return root;
    }

    @Override
    public Object left(Object node) {
        return ((Node<E>) node).left;
    }

    @Override
    public Object right(Object node) {
        return ((Node<E>) node).right;
    }

    @Override
    public Object string(Object node) {
        Node<E> myNode = (Node<E>) node;
        String parentString = "null";
        if (myNode.parent != null) {
            parentString = myNode.parent.element.toString();
        }
        return myNode.element + "(↑" + parentString + ")";
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        toString(root, sb, "");
        return sb.toString();
    }


    //计算二叉树高度（递归）
    public int height() {
        return height(root);
    }

    private int height(Node<E> node) {
        if (node == null) return 0;
        return 1 + Math.max(height(node.left), height(node.right));
    }

    //计算二叉树高度（迭代）,层序遍历
    public int height1() {
        if (root == null) return 0;
        int height = 0;//树的高度
        int levelSize = 1;//每一层的元素个数
        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            Node<E> node = queue.poll();
            levelSize--;//本层元素数量--
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
            if (levelSize == 0) {//levelSize=0 意味着本层已经全部出栈， 准备访问下一层
                //下一层元素数量是队列的size;
                levelSize = queue.size();
                height++;
            }
        }
        return height;
    }


    public boolean isComplete() {
        if (root == null) return false;
        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);
        boolean leaf = false;
        while (!queue.isEmpty()) {
            Node<E> node = queue.poll();
            if (leaf && !node.isLeaf()) return false;//要的是叶子节点，给的不是
            if (node.left != null) {
                queue.offer(node.left);
            } else if (node.right != null) {//左边空， 右边不空
                return false;
            }
            if (node.right != null) {
                queue.offer(node.right);
            } else {//右边为空， 需要判断剩下的所有节点必须都是叶子节点
                leaf = true;
            }
        }
        return true;
    }


    private void toString(Node<E> node, StringBuilder sb, String prefix) {
        if (node == null) return;

        toString(node.left, sb, prefix + "L---");
        sb.append(prefix).append(node.element).append("\n");
        toString(node.right, sb, prefix + "R---");
    }

}
